/*
 * lex.cpp
 *
 *   Created on: 2011-9-24
 *       Author: 左白
 *  Description: 词法分析模块-实现
 */

#include "util.h"
#include <cstring>

using namespace std;

namespace zach
{
#if (1) /* 库部分 */
// 关键字
struct KeyWord
{
	const char* str; // 字符串
	LexType lexType; // 词法类型
};

KeyWord keyWords[] = { { "if", lexType::If }, { "true", lexType::True }, { "false", lexType::False }, { "trait", lexType::Trait } };

// 小写字母
#define CASE_LOWER_CASE_ALPHA\
	case 'a':\
	case 'b':\
	case 'c':\
	case 'd':\
	case 'e':\
	case 'f':\
	case 'g':\
	case 'h':\
	case 'i':\
	case 'j':\
	case 'k':\
	case 'l':\
	case 'm':\
	case 'n':\
	case 'o':\
	case 'p':\
	case 'q':\
	case 'r':\
	case 's':\
	case 't':\
	case 'u':\
	case 'v':\
	case 'w':\
	case 'x':\
	case 'y':\
	case 'z':\

// 大写字母
#define CASE_UPPER_CASE_ALPHA\
	case 'A':\
	case 'B':\
	case 'C':\
	case 'D':\
	case 'E':\
	case 'F':\
	case 'G':\
	case 'H':\
	case 'I':\
	case 'J':\
	case 'K':\
	case 'L':\
	case 'M':\
	case 'N':\
	case 'O':\
	case 'P':\
	case 'Q':\
	case 'R':\
	case 'S':\
	case 'T':\
	case 'U':\
	case 'V':\
	case 'W':\
	case 'X':\
	case 'Y':\
	case 'Z':

// 字母
#define CASE_ALPHA\
	CASE_LOWER_CASE_ALPHA\
	CASE_UPPER_CASE_ALPHA

// 数字
#define CASE_NUMBER\
	case '0':\
	case '1':\
	case '2':\
	case '3':\
	case '4':\
	case '5':\
	case '6':\
	case '7':\
	case '8':\
	case '9':

// 数字+字母
#define CASE_ALPHA_NUM\
	CASE_ALPHA\
	CASE_NUMBER

// 标记首字符,字母+下划线
#define CASE_TOKEN_INIT\
	CASE_ALPHA\
	case '_':

// 标记字符,字母+数字+下划线
#define CASE_TOKEN\
	CASE_ALPHA_NUM\
	case '_':

// 空白符
#define CASE_BLANK\
	case ' ':\
	case '\t':\
	case '\v':\
	case '\n':

// 文件结束
#define CASE_EOF\
	case -1:

#if (1) /* 标记状态机 */
// 标记状态
struct TokenState
{
	TokenState()
	{
		// 将通往下一层的出口清空
		for ( int i = 0; i != 26; ++i ) {
			next[i] = null;
			isFinal = false;
		}
	}

	TokenState* next[26]; // 下一层
	LexType lexType; // 词法类型
	bool isFinal; // 是否是一个终结点,即在此结束可构成一个词
};

typedef TokenState* TokenStateTable; // 标记状态表

// 标记状态机
class TokenStateMachine
{
public:
	TokenStateMachine( TokenStateTable tokenStateTable )
	{
		_root = tokenStateTable;
	}

	// 操作,开启一个新词
	void startWord()
	{
		_curState = _root;
		_isCurWordCanBeKey = true;
		_isCurWordEnd = false;
	}

	// 操作,读入一个字符
	void readChar( Char c );

	// 属性,当前的词是否已经读完
	bool isCurWordEnd()
	{
		return _isCurWordEnd;
	}

	// 属性,当前的词是否是关键词
	bool isCurWordKeyWord()
	{
		return _isCurWordCanBeKey && _curState->isFinal; // 当前词仍可能是关键词并且已经完结
	}

	// 属性,当前的读到词的词法类型
	LexType curWordLexType()
	{
		return _curState->lexType;
	}

private:
	// 操作,添加一个关键词
	void addKeyword( const char* str, LexType lexType );

	TokenStateTable _root; // 根节点
	TokenState* _curState; // 当前的状态
	bool _isCurWordCanBeKey; // 当前的这个词是否能成为关键词
	bool _isCurWordEnd; // 当前的这个词是否已经读完,即读到了_a-zA-Z
};

// 生成词法状态表
TokenStateTable genTokenStateTable( KeyWord* keyWords, int numKeyWords )
{
	// 创建根节点
	TokenState* root = new TokenState();

	// 添加关键词
	for ( int i = 0; i != numKeyWords; ++i ) {
		const char* str = keyWords[i].str;
		LexType lexType = keyWords[i].lexType;

		TokenState* curNode = root; // 当前节点

		// 创建路径
		for ( int i = 0, l = strlen( str ); i != l; ++i ) {
			int index = str[i] - 'a';
			// 如果不是小写字母,错误
			if ( index < 0 || index > 25 ) {
				throw Fault( "Invalid keyword" );
			}

			// 如果该支路还没有创建,创建它
			if ( curNode->next[index] == null ) {
				curNode->next[index] = new TokenState();
			}

			// 进入该节点
			curNode = curNode->next[index];
		}

		// 标记为节点
		curNode->isFinal = true;
		curNode->lexType = lexType;
	}

	return root;
}

void TokenStateMachine::readChar( Char c )
{
	// 如果之前结束了,重新开始一个新词
	if ( _isCurWordEnd ) {
		throw Fault( "Word is end, please start a new word" );
	}

	if ( _isCurWordCanBeKey ) {
		// 如果仍可能成为关键词
		switch ( c ) {
			CASE_LOWER_CASE_ALPHA
				// 小写字母,如果找得到路,那么继续往下走
				if ( _curState->next[c - 'a'] != null ) {
					_curState = _curState->next[c - 'a'];
				}
				else {
					// 找不到路,没可能成为关键字了
					_isCurWordCanBeKey = false;
				}
				break;
			CASE_UPPER_CASE_ALPHA
			CASE_NUMBER
			case '_':
				// 没可能成为关键词了
				_isCurWordCanBeKey = false;
				break;
			default:
				// 读完了
				_isCurWordEnd = true;
				break;
		}
	}
	else {
		// 没可能成为关键词了
		switch ( c ) {
			CASE_TOKEN
				// 啥事不做
				break;
			default:
				// 读完了
				_isCurWordEnd = true;
				break;
		}
	}
}
#endif /* 标记状态机 */

// 另字符被'引'起来
static string toQuoteForm( string str )
{
	string retVal;
	retVal += '\'';
	retVal += str;
	retVal += '\'';
	return retVal;
}

// 将字符转化为可以读的字符串,主要指转化\n和\t
static string toReadableString( Char c )
{
	switch ( c ) {
		case '\n':
			return "\\n";
		case '\t':
			return "\\t";
		default:
			return toString( c );
	}
}

static inline string toQuoteForm( Char c )
{
	return toQuoteForm( toReadableString( c ) );
}

// 转换到escape形式
static string toEscapeForm( Char c )
{
	return toQuoteForm( '\\' + toReadableString( c ) );
}
#endif /* 库部分 */

#if (1) /* parseLex实现 */
LexText parseLex( const string& path )
{
#if (1) /* 声明 */
	static TokenStateTable keyWordTable = genTokenStateTable( keyWords, LENGTH( keyWords ) ); // 关键词状态表
	TokenStateMachine tokenStateMachine( keyWordTable ); // Token状态机

	// 词法分析状态
	enum LexState
	{
		INIT, TOKEN, NUMBER, DECIMAL_FIRST, DECIMAL, ADD, SUB, MUL, DIV, COLON, AND, OR, QUOTE, DQUOTE, DQUOTE_ERROR, LESS, MORE, ASSIGN, XOR, NOT,
		WAVE, QUOTE_END, QUOTE_ERROR, ESCAPE, VBSTRING_LEFT_BOUND, VBSTRING_CONTENT, VBSTRING_RIGHT_BOUND, VBSTRING_RIGHT_BOUND_END,
		VBSTRING_RECOVERY_CONTENT, LEFT_SHIFT, RIGHT_SHIFT_LOGIC, RIGHT_SHIFT_ARITHMETIC, LINE_ANNOTATION, BLOCK_ANNOTATION, BLOCK_ANNOTATION_END,
		INC, DEC
	};

	LexWords resultText; // 结果文本
	util::UTF8Reader reader; // 阅读器
	util::StringBuilder builder; // 字符串构建器
	Char c; // 当前的字符
	TextPosition curWordStartPosition; // 当前单词的起始位置
	bool isDone = false; // 是否完成(读到EOF)

	LexState curState; // 当前状态
	LexState returnState; // 返回状态,用于转义字符的跳回;由于词法分析中不会有嵌套,因此一个nextState足够解决问题
	LexState returnErrorState; // 返回错误状态,用于转义状态的跳回

	CharVector assistCharBuffer; // 辅助的字符缓冲,主要用于实现变界字符串
	int leftBoundLength = 0; // 变界串左边界长
	int rightBoundLength = 0; // 变界串右边界长
#endif /* 声明 */

#if (1) /* 动作 */
	// 读一个字符到c中,若文件结束则置c为-1
	class ReadChar
	{
	public:
		ReadChar( util::UTF8Reader& reader, Char& c ) :
				_reader( reader ), _c( c )
		{
		}

		inline void operator()()
		{
			_reader.readChar(); // 读字符
			_c = _reader.isEnd() ? -1 : _reader.lastRead(); // 放到c中,若文件结束则将c置为-1
		}
	private:
		util::UTF8Reader& _reader;
		Char& _c;
	} readChar( reader, c );

	// 开始一个单词,记录这个单词在文件中的位置
	class StartWord
	{
	public:
		StartWord( util::UTF8Reader& reader, TextPosition& startPos ) :
				_reader( reader ), _startPos( startPos )
		{
		}

		inline void operator()()
		{
			_startPos = _reader.position();
		}
	private:
		util::UTF8Reader& _reader;
		TextPosition& _startPos;
	} startWord( reader, curWordStartPosition );

	// 储存一个字符
	class StoreChar
	{
	public:
		StoreChar( Char& c, util::StringBuilder& builder ) :
				_c( c ), _builder( builder )
		{
		}

		// 将全局的c存入builder中
		void operator()()
		{
			_builder.pushChar( _c );
		}

		// 将指定的Char存入builder中
		void operator()( Char c )
		{
			_builder.pushChar( c );
		}

		// 将一个Char组存入buidler中
		void operator()( CharVector chars )
		{
			_builder.pushChars( chars );
		}
	private:
		Char& _c;
		util::StringBuilder& _builder;
	} storeChar( c, builder );

	// 完成一个词法词,存入到结果文本中
	class FinishWord
	{
	public:
		FinishWord( LexWords& resultText, TextPosition& startPos, util::StringBuilder& builder ) :
				_resultText( resultText ), _startPos( startPos ), _builder( builder )
		{
		}

		// 存入储存的词法词
		void operator()( LexType type )
		{
			_builder.build(); // 构建单词
			_resultText.push_back( LexWord( type, _startPos, _builder.lastBuild() ) ); // 存入词法词
		}

		// 存入词法词,内容为指定的字符串
		void operator()( LexType type, const char* str )
		{
			_builder.build(); // 构建单词
			_resultText.push_back( LexWord( type, _startPos, getString( str ) ) ); // 存入词法词
		}

		// 存入词法词,内容为单个字符
		void operator()( LexType type, char ch )
		{
			_builder.build(); // 构建单词
			_resultText.push_back( LexWord( type, _startPos, getString( ch ) ) ); // 存入词法词
		}
	private:
		LexWords& _resultText;
		TextPosition& _startPos;
		util::StringBuilder& _builder;
	} finishWord( resultText, curWordStartPosition, builder );

	// 跳转状态并读下一个单词
#define jumpAndRead( nextState )\
	curState = nextState;\
	readChar()

	// 结束单词,跳回INIT状态
#define endWord( ... )\
		finishWord( __VA_ARGS__ );\
		curState = INIT

	// 调用状态,注明返回状态和返回错误状态
#define callState( targetState, rState, rErrorState )\
	curState = targetState;\
	returnState = rState;\
	returnErrorState = rErrorState

	// 转换状态并读字符
#define TURN_STATE_WITH_NEW_CHAR_WITHOUT_STORE( turnCase, targetState )\
	turnCase\
		jumpAndRead( targetState );\
		break;

	// 转换状态储存字符并读字符
#define TURN_STATE_WITH_NEW_CHAR_WITH_STORE( turnCase, targetState )\
	turnCase\
		storeChar();\
		jumpAndRead( targetState );\
		break;

	// 单字符标点
#define UNICHAR_MARK( charCase, type )\
	case charCase:\
		startWord();\
		endWord( type );\
		readChar();\
		break;

	// 开启一个无界无限词,开启单词,储存字符,跳转状态,读下一个字符
#define START_WORD( startCase, nextState )\
	startCase\
		startWord();\
		storeChar();\
		jumpAndRead( nextState );\
		break;

	// 根据一个字符开启一个界词,根据对应的字符切换状态,开启单词,并读下一个字符
#define START_BOUND_WORD( startChar, nextState )\
	case startChar:\
		startWord();\
		jumpAndRead( nextState );\
		break;

	// 开始一个标点,根据对应的字符切换状态,开启单词,储存字符,并读下一个字符
#define START_MARK( startChar, nextState )\
	START_BOUND_WORD( startChar, nextState )

	// 结束一个标点,储存当前字符,跳回INIT状态,读下一个单词
#define END_MARK( endChar, type )\
	case endChar:\
		endWord( type );\
		readChar();\
		break;

	// 继续标点,根据对应的字符切换状态,储存当前字符,并读下一个字符
#define CONTINUE_MARK( continueChar, nextState )\
	case continueChar:\
		jumpAndRead( nextState );\
		break;

	// 结束大嘴,即结束当前的词,将当前的字符交由INIT处理
#define END_MARK_BIG_MOUTH( type )\
	default:\
		endWord( type );\
		break;

	// 转义字符,储存该转义字符,跳回return状态,读下一个字符
#define ESCAPE_CHAR( originChar, escapeChar )\
	case originChar:\
		storeChar( escapeChar );\
		curState = returnState;\
		readChar();\
		break;

	// 继续无界词,存储当前读得,读下一个,状态不变
#define CONTINUE_UNLIMITED_WORD( continueCase )\
	continueCase\
		storeChar();\
		readChar();\
		break;

	// 结束无限有界词
#define END_UNLIMITED_BOUND_WORD( bound, type )\
	case bound:\
		endWord( type );\
		readChar();\
		break;

	// 结束无限无界词,即界留给INIT处理
#define END_UNLIMITED_UNBOUND_WORD( type )\
	default:\
		endWord( type );\
		break;

#endif /* 动作 */

#if (1) /* 错误处理部分 */
	vector<ParseError> errors; // 错误收集

	// 当前位置
#define curPos\
		FILEPOSITION( path, reader.position() )

	// 抛出错误
#define throwError( errorNumber, description  )\
		errors.push_back( ParseError( curPos, errorNumber, description ) )

	// 因为读到了EOF而导致的错误
#define EOF_ERROR( errorNumber, description )\
	CASE_EOF\
		throwError( errorNumber, description );\
		isDone = true;\
		break;

#endif /* 错误处理部分 */

#if (1) /* 正文 */
	// 初始化工作
	reader.init( path ); // 绑定流
	curState = INIT; // 状态机的状态,初始为init
	readChar(); // 读第一个字符

#if (1) /* 主循环 */
	while ( !isDone ) {
		switch ( curState ) {
#if (1) /* 初态 */
			case INIT:
				// 初始状态
				switch ( c ) {
					CASE_TOKEN_INIT
						// 开启一个标记
						startWord();
						tokenStateMachine.startWord();
						tokenStateMachine.readChar( c );
						storeChar();
						jumpAndRead( TOKEN );
						break;

					START_WORD( CASE_NUMBER, NUMBER )

					START_MARK( '+', ADD )
					START_MARK( '-', SUB )
					START_MARK( '*', MUL )
					START_MARK( '&', AND )
					START_MARK( '|', OR )
					START_MARK( '>', MORE )
					START_MARK( '!', NOT )
					START_MARK( '^', XOR )
					START_MARK( '=', ASSIGN )

					START_BOUND_WORD( '/', DIV )
					START_BOUND_WORD( '<', LESS )
					START_BOUND_WORD( '\'', QUOTE )
					START_BOUND_WORD( '\"', DQUOTE )

					UNICHAR_MARK( '~', lexType::Negate )
					UNICHAR_MARK( '@', lexType::At )
					UNICHAR_MARK( '#', lexType::Sharp )
					UNICHAR_MARK( '$', lexType::Dollar )
					UNICHAR_MARK( '(', lexType::LeftRound )
					UNICHAR_MARK( ')', lexType::RightRound )
					UNICHAR_MARK( '[', lexType::LeftSquare )
					UNICHAR_MARK( ']', lexType::RightSquare )
					UNICHAR_MARK( '{', lexType::LeftBig )
					UNICHAR_MARK( '}', lexType::RightBig )
					UNICHAR_MARK( ':', lexType::Colon )
					UNICHAR_MARK( ';', lexType::Semicolon )
					UNICHAR_MARK( ',', lexType::Comma )
					UNICHAR_MARK( '.', lexType::Period )
					UNICHAR_MARK( '?', lexType::Question )

					CASE_BLANK
						// 空白符,忽略,读下一个字符
						readChar();
						break;
					CASE_EOF
						// 文件读完,退出循环
						isDone = true;
						break;
					default:
						// 读到非法字符,抛出错误,忽略,读下一个字符
						throwError( errorNumber::INVALID_CHAR, util::concat( "Invalid char ", c ) );
						readChar();
						break;
				}
				break;
#endif /* 初态 */
#if (1) /* 非定界无限串,TOKEN,NUMBER,DECIMAL */
			case TOKEN:
				tokenStateMachine.readChar( c );
				// 是否读完
				if ( tokenStateMachine.isCurWordEnd() ) {
					// 读完了,是否是关键词
					if ( tokenStateMachine.isCurWordKeyWord() ) {
						// 是关键词,以关键词储存之,不存储内容
						endWord( tokenStateMachine.curWordLexType(), "" );
					}
					else {
						// 否则记为Token
						endWord( lexType::TOKEN );
					}
				}
				else {
					// 否则继续读
					storeChar();
					readChar();
				}
				break;
			case NUMBER:
				switch ( c ) {
					CONTINUE_UNLIMITED_WORD( CASE_NUMBER )
					TURN_STATE_WITH_NEW_CHAR_WITH_STORE( case '.':, DECIMAL_FIRST )
					END_UNLIMITED_UNBOUND_WORD( lexType::INT )
				}
				break;
			case DECIMAL_FIRST:
				// 小数点后第一个字符,必须是数字
				switch ( c ) {
					TURN_STATE_WITH_NEW_CHAR_WITH_STORE( CASE_NUMBER, DECIMAL )
					default:
						// 否则错误
						throwError( errorNumber::WRONG_DECIMAL_FORM, util::concat( "Wrong decimal form, unexpected ", toQuoteForm( c ) ) );
						endWord( lexType::E );
						readChar();
						break;
				}
				break;
			case DECIMAL:
				switch ( c ) {
					CONTINUE_UNLIMITED_WORD( CASE_NUMBER )
					END_UNLIMITED_UNBOUND_WORD( lexType::DOUBLE )
				}
				break;
#endif /* 非定界无限串,TOKEN和NUMBER */
#if (1) /* 引号状态 */
			case QUOTE:
				// 读到了第一个单引号,应该读字符了,QUOTE的出口是QUOTE_END或QUOTE_ERROR
				switch ( c ) {
					case '\'':
						// 读到了单引号,错误,结束单词,读下一个字符
						throwError( errorNumber::EMPTY_IN_SINGLE_QUOTES_PAIR, "Empty in single quotes pair" );
						endWord( lexType::CHAR );
						readChar();
						break;
					case '\n':
						// 读到了换行,错误,读下一个字符,进入QUOTE_ERROR状态
						throwError( errorNumber::LINE_FEED_IN_SINGLE_QUOTES_PAIR, "Line feed in single quotes pair" );
						jumpAndRead( QUOTE_ERROR );
						break;
					case '\\':
						// 读到了反斜杠,读下一个字符,Call转义状态
						readChar();
						callState( ESCAPE, QUOTE_END, QUOTE_ERROR );
						break;
					EOF_ERROR( errorNumber::UNMATCHED_SINGLE_QUOTES, "Unmatched single quotes, unexpected EOF" )
					default:
						// 其它字符,储存,读下一个字符,进入QUOTE_END状态
						storeChar();
						readChar();
						curState = QUOTE_END;
						break;
				}
				break;
			case QUOTE_END:
				// 读完了单引号中的字符内容,应该读结束单引号了
				switch ( c ) {
					END_UNLIMITED_BOUND_WORD( '\'', lexType::CHAR )
					EOF_ERROR( errorNumber::UNMATCHED_SINGLE_QUOTES, "Unmatched single quotes, unexpected EOF" )
					default:
						// 读到了其他字符,错误,读字符,进入QUOTE_ERROR状态
						throwError( errorNumber::SUPERFLUOUS_CHAR_IN_SINGLE_QUOTES_PAIR, "Superfluous char in single quotes pair" );
						jumpAndRead( QUOTE_ERROR );
						break;
				}
				break;
			case QUOTE_ERROR:
				// 上单引号和第一个单引号已经读完,读到结束单引号为止
				switch ( c ) {
					END_UNLIMITED_BOUND_WORD( '\'', lexType::E )
					EOF_ERROR( errorNumber::UNMATCHED_SINGLE_QUOTES, "Unmatched single quotes, unexpected EOF" )
					CONTINUE_UNLIMITED_WORD( default: )
				}
				break;
			case ESCAPE:
				// 读到了反斜杠
				switch ( c ) {
					ESCAPE_CHAR( 'a', 7 )
					ESCAPE_CHAR( 'b', 8 )
					ESCAPE_CHAR( 'f', 12 )
					ESCAPE_CHAR( 'n', 10 )
					ESCAPE_CHAR( 'r', 13 )
					ESCAPE_CHAR( 't', 9 )
					ESCAPE_CHAR( 'v', 11 )
					ESCAPE_CHAR( '\'', 39 )
					ESCAPE_CHAR( '\"', 34 )
					ESCAPE_CHAR( '\\', 92 )
					EOF_ERROR( errorNumber::INVALID_ESCAPE_CHAR, "Invalid escape char, Unexpected EOF" )
					default:
						// 错误,读下一个字符,进入nextError状态
						throwError( errorNumber::INVALID_ESCAPE_CHAR, util::concat( "Invalid escape char ", toEscapeForm( c ) ) );
						jumpAndRead( returnErrorState );
						break;
				}
				break;
			case DQUOTE:
				switch ( c ) {
					END_UNLIMITED_BOUND_WORD( '\"', lexType::STRING )
					case '\n':
						// 遇到换行,抛出错误,继续读
						throwError( errorNumber::LINE_FEED_IN_DOUBLE_QUOTES_PAIR, "Line feed in double quotes pair" );
						jumpAndRead( DQUOTE_ERROR );
						break;
					EOF_ERROR( errorNumber::UNMATHCED_DOUBLE_QUOTES, "Unmatched double quotes, unexpected EOF" )
					case '\\':
						// 读到反斜杠,读下一个字符,Call转义状态
						readChar();
						callState( ESCAPE, DQUOTE, DQUOTE );
						break;
					CONTINUE_UNLIMITED_WORD( default: )
				}
				break;
			case DQUOTE_ERROR:
				switch ( c ) {
					END_UNLIMITED_BOUND_WORD( '\"', lexType::E )
					EOF_ERROR( errorNumber::UNMATHCED_DOUBLE_QUOTES, "Unmatched double quotes, unexpected EOF" )
					CONTINUE_UNLIMITED_WORD( default: )
				}
				break;
#endif /* 引号状态 */
#if (1) /* <起始状态 */
			case LESS:
				// 读到了<,有<=,<<,<<=,<--后续
				switch ( c ) {
					case '-':
						// 读到了<-,加一个-长度,进入VBSTRING_LEFT_BOUND状态,读下一个字符
						++leftBoundLength;
						jumpAndRead( VBSTRING_LEFT_BOUND );
						break;
					default:
						// 否则是标点语义,首先先储存<
						storeChar( c );
						switch ( c ) {
							END_MARK( '=', lexType::LessEqual )
							CONTINUE_MARK( '<', LEFT_SHIFT )
							END_MARK_BIG_MOUTH( lexType::Less )
						}
						break;
				}
				break;
			case VBSTRING_LEFT_BOUND:
				// 读到了<-,若读到<则进入字符串内容,读到-则继续,读到其它错误,该字符交由INIT处理
				switch ( c ) {
					case '-':
						// 读到了-,加边界长度,继续读
						++leftBoundLength;
						readChar();
						break;
					case '<':
						// 读到了<,设置右边界长度为左边界,跳到VBSTRING_CONTENT状态,继续读
						rightBoundLength = leftBoundLength;
						jumpAndRead( VBSTRING_CONTENT );
						break;
					default:
						// 读到了其它字符,抛出错误,左边界长度清0,结束单词,不处理该字符
						leftBoundLength = 0;
						throwError( errorNumber::UNRECOGNIZED_CHAR_SEQUENCE_EXPECTED_LESS, "Unrecognized char sequence, expected <" );
						endWord( lexType::E );
						break;
				}
				break;
			case VBSTRING_CONTENT:
				switch ( c ) {
					EOF_ERROR( errorNumber::UNFINSHED_VBSTRING, "Unfinshed vbstring, unexpected EOF" )
					case '>':
						// 读到了<,读下一个字符,进入右边界,储存该字符
						assistCharBuffer.push_back( '>' );
						curState = VBSTRING_RIGHT_BOUND;
						readChar();
						break;
					CONTINUE_UNLIMITED_WORD( default: )
				}
				break;
			case VBSTRING_RIGHT_BOUND:
				// 读到了>
				switch ( c ) {
					case '-':
						// 读到了>-..,根据-的数量决定走向,储存这个-,读下一个字符
						assistCharBuffer.push_back( '-' );
						--rightBoundLength; // 减少rightBoundLength的量
						if ( rightBoundLength == 0 ) {
							// 如果-读够了,转到VBSTRING_RIGHT_BOUND_END状态
							curState = VBSTRING_RIGHT_BOUND_END;
						}
						readChar();
						break;
					default:
						// 不是-号,跳到VBSTRING_RECOVERY_CONTENT状态,不读字符
						curState = VBSTRING_RECOVERY_CONTENT;
						break;
				}
				break;
			case VBSTRING_RIGHT_BOUND_END:
				// 读到了够数的>---...,准备读结束的>
				switch ( c ) {
					case '>':
						// 结束VBSTRING,清空各种状态,读下一个字符
						endWord( lexType::STRING );
						leftBoundLength = 0; // 左边界计数清0
						assistCharBuffer.clear(); // 辅助缓冲清0
						readChar();
						break;
					default:
						// 不是>号,跳到VBSTRING_RECOVERY_CONTENT状态,不读字符
						curState = VBSTRING_RECOVERY_CONTENT;
						break;
				}
				break;
			case VBSTRING_RECOVERY_CONTENT:
				switch ( c ) {
					EOF_ERROR( errorNumber::UNFINSHED_VBSTRING, "Unfinshed vbstring, unexpected EOF" )
					default:
						// 存储先前为存储的内容,重置部分状态,跳回VBSTRING_CONTENT,不读字符,当前的字符有VBSTRING_CONTENT处理
						rightBoundLength = leftBoundLength; // 重置计数
						// 将辅助缓冲中的内容存入,并清空
						storeChar( assistCharBuffer );
						assistCharBuffer.clear();
						curState = VBSTRING_CONTENT;
						break;
				}
				break;
#endif /* <起始状态 */
#if (1) /* >起始状态 */
			case MORE:
				// 读到了>,有>=,>>,>>>,>>=,>>>=等后续
				switch ( c ) {
					END_MARK( '=', lexType::GreatEqual )
					CONTINUE_MARK( '>', RIGHT_SHIFT_LOGIC )
					END_MARK_BIG_MOUTH( lexType::Great )
				}
				break;
			case RIGHT_SHIFT_LOGIC:
				// 读到了>>,有>>,>>>,>>=,>>>=等后续
				switch ( c ) {
					END_MARK( '=', lexType::GreatGreatEqual )
					CONTINUE_MARK( '>', RIGHT_SHIFT_ARITHMETIC )
					END_MARK_BIG_MOUTH( lexType::GreatGreat )
				}
				break;
			case RIGHT_SHIFT_ARITHMETIC:
				// 读到了>>>,有>>>和>>>=
				switch ( c ) {
					END_MARK( '=', lexType::GreatGreatGreat )
					END_MARK_BIG_MOUTH( lexType::GreatGreatGreatEqual )
				}
				break;
#endif /* >起始状态 */
#if (1) /* /起始状态 */
			case DIV:
				// 读到了/,有/=,//,/*等后续
				switch ( c ) {
					TURN_STATE_WITH_NEW_CHAR_WITHOUT_STORE( case '/':, LINE_ANNOTATION )
					TURN_STATE_WITH_NEW_CHAR_WITHOUT_STORE( case '*':, BLOCK_ANNOTATION )
					default:
						// 负责是标点语义,先储存一个/
						storeChar( '/' );
						switch ( c ) {
							END_MARK( '=', lexType::DivEqual )
							END_MARK_BIG_MOUTH( lexType::Div )
						}
						break;
				}
				break;
			case LINE_ANNOTATION:
				// 读到了//,等\n
				switch ( c ) {
					END_UNLIMITED_BOUND_WORD( '\n', lexType::LINE_ANNOTATION )
					EOF_ERROR( errorNumber::UNFINSHED_LINE_ANNOTATION, "Unfinshed line annotation, unexpected EOF" )
					CONTINUE_UNLIMITED_WORD( default: )
				}
				break;
			case BLOCK_ANNOTATION:
				// 读到了/*,期待*/
				switch ( c ) {
					TURN_STATE_WITH_NEW_CHAR_WITHOUT_STORE( case '*':, BLOCK_ANNOTATION_END )
					EOF_ERROR( errorNumber::UNFINSHED_BLOCK_ANNOTATION, "Unfinshed block annotation, unexpected EOF" )
					CONTINUE_UNLIMITED_WORD( default: )
				}
				break;
			case BLOCK_ANNOTATION_END:
				switch ( c ) {
					END_UNLIMITED_BOUND_WORD( '/', lexType::BLOCK_ANNOTATION )
					EOF_ERROR( errorNumber::UNFINSHED_BLOCK_ANNOTATION, "Unfinshed block annotation, unexpected EOF" )
					default:
						// 否则跳回BLOCK_ANNOTATION状态,不处理当前字符,储存*
						curState = BLOCK_ANNOTATION;
						storeChar( '*' );
						break;
				}
				break;
#endif /* /起始状态 */
#if (1) /* +开始状态 */
			case ADD:
				// 读到了+,有+=,++,+Number等后续
				switch ( c ) {
					CASE_NUMBER
						storeChar( '+' );
						storeChar();
						jumpAndRead( NUMBER );
						break;
					END_MARK( '+', lexType::AddAdd )
					END_MARK( '=', lexType::AddEqual )
					END_MARK_BIG_MOUTH( lexType::Add )
				}
				break;
#endif /* +开始状态 */
#if (1) /* -开始状态 */
			case SUB:
				// 读到了-,有-=,--,-Number等后续
				switch ( c ) {
					CASE_NUMBER
						storeChar( '-' );
						storeChar();
						jumpAndRead( NUMBER );
						break;
					END_MARK( '-', lexType::SubSub )
					END_MARK( '=', lexType::SubEqual )
					END_MARK_BIG_MOUTH( lexType::Sub )
				}
				break;
#endif /* -开始状态 */
#if (1) /* 其它简单操作符 */
			case MUL:
				// *,*=
				switch ( c ) {
					END_MARK( '=', lexType::MulEqual )
					END_MARK_BIG_MOUTH( lexType::Mul )
				}
				break;
			case AND:
				// &,&&,&=
				switch ( c ) {
					END_MARK( '&', lexType::AndAnd )
					END_MARK( '=', lexType::AddEqual )
					END_MARK_BIG_MOUTH( lexType::And )
				}
				break;
			case OR:
				// |,||,|=
				switch ( c ) {
					END_MARK( '|', lexType::OrOr )
					END_MARK( '=', lexType::OrEqual )
					END_MARK_BIG_MOUTH( lexType::Or )
				}
				break;
			case NOT:
				// !,!=
				switch ( c ) {
					END_MARK( '=', lexType::NotEqual )
					END_MARK_BIG_MOUTH( lexType::Not )
				}
				break;
			case ASSIGN:
				// =,==
				switch ( c ) {
					END_MARK( '=', lexType::EqualEqual )
					END_MARK_BIG_MOUTH( lexType::Equal )
				}
				break;
			case XOR:
				// ^,^=
				switch ( c ) {
					END_MARK( '=', lexType::XorEqual )
					END_MARK_BIG_MOUTH( lexType::Xor )
				}
				break;
#endif /* 其它简单操作符 */
		}
	}
#endif /* 主循环 */

	// 如果错误不为空,抛出
	if ( !errors.empty() ) {
		die( errors );
	}
	return LexText( path, resultText );
#endif /* 正文 */
}
#endif /* parseLex实现 */

}
